package com.yxc.optionaldemo;

import org.junit.Test;

import java.util.Optional;

/**
 * @author: YXC
 * @time: 2022/12/30 11:16
 **/
public class OptionalTest {

    @Test
    public void getTest() {
        String strNull = null;
        String strNotNull = "str not null";
        Optional<String> optionalNull = Optional.ofNullable(strNull);
        Optional<String> optionalNotNull = Optional.ofNullable(strNotNull);

        System.out.println("\n=========================== orElse方法\n");

        // orElse，如果optional对象的value为空，则返回orElse函数的参数
        String strNull1 = optionalNull.orElse("orElse Null");
        String strNotNull1 = optionalNotNull.orElse("orElse Not Null");
        // orElse Null
        System.out.println(strNull1);
        // str not null
        System.out.println(strNotNull1);

        System.out.println("\n=========================== orElseGet方法\n");

        // orElseGet，如果optional对象的value为空，则返回orElseGet函数的Supplier函数生成的值
        String strNull2 = optionalNull.orElseGet(() -> "orElseGet Null");
        String strNotNull2 = optionalNotNull.orElseGet(() -> "orElseGet Not Null");
        // orElseGet Null
        System.out.println(strNull2);
        // str not null
        System.out.println(strNotNull2);

        System.out.println("\n=========================== orElseThrow方法\n");

        // orElseThrow，当optional的内置对象为空的时候，执行orElseThrow函数的Supplier函数抛出的方法
        try {
            optionalNull.orElseThrow(() -> new RuntimeException("optionalNull 内置对象为空"));
        } catch (RuntimeException e) {
            System.out.println("optionalNull 抛出异常 " + e.getMessage());
        }
        try {
            optionalNotNull.orElseThrow(() -> new RuntimeException("optionalNotNull 内置对象为空"));
        } catch (RuntimeException e) {
            System.out.println("optionalNotNull 抛出异常 " + e.getMessage());
        }

        System.out.println("\n=========================== isPresent方法\n");

        // isPresent，如果optional内对象为空，则返回false，否则返回true
        if (optionalNull.isPresent()) {
            // false
            System.out.println("optional null 不为空");
        }
        if (optionalNotNull.isPresent()) {
            // true
            System.out.println("optional not null 不为空");
        }

        System.out.println("\n=========================== ifPresent方法\n");

        // ifPresent，如果optional内置对象为空，则执行ifPresent函数的Consumer函数
        // 不输出
        optionalNull.ifPresent(System.out::println);
        // str not null
        optionalNotNull.ifPresent(System.out::println);

        System.out.println("\n=========================== filter方法\n");

        // filter，如果optional的内置对象不为空，则执行filter函数的Predicate函数P，如果函数P的值为true，则返回原本的optional，否则返回空的optional
        // 如果optional的内置对象为空，则返回空的optional
        Optional<String> s1 = optionalNull.filter(s -> s != null);
        Optional<String> s2 = optionalNotNull.filter(s -> s != null);
        // Optional.empty
        System.out.println(s1);
        // Optional[str not null]
        System.out.println(s2);

        System.out.println("\n=========================== map方法\n");

        // map，如果optional的内置对象为空，则返回空的optional
        // 如果optional的内置对象不为空，则返回由map函数的Function函数处理之后的结果，直接用optional包装
        Optional<String> s3 = optionalNull.map(s -> s + " map处理");
        Optional<String> s4 = optionalNotNull.map(s -> s + " map处理");
        // Optional.empty
        System.out.println(s3);
        // Optional[str not null map处理]
        System.out.println(s4);

        System.out.println("\n=========================== map方法\n");

        // flatMap，如果optional的内置对象为空，则返回空的optional
        // 如果optional的内置对象不为空，则返回flatMap函数的Function函数返回的optional
        Optional<String> s5 = optionalNull.flatMap(s -> Optional.ofNullable(s + " flatMap处理"));
        Optional<String> s6 = optionalNotNull.flatMap(s -> Optional.ofNullable(s + " flatMap处理"));
        // Optional.empty
        System.out.println(s5);
        // Optional[str not null flatMap处理]
        System.out.println(s6);
    }
}
